var FlyUI = require("FlyUI");

var FileServe = require("FileServe");

var UIManage = require("UIManage");

var SoundManage = require("SoundManage");

var FactoryItem = cc.Class({
  extends: cc.Component,

  statics: {
    Instance: null,
  },

  properties: {
    ItemPrefabs: cc.Prefab,
    // ItemParent:cc.Node,
    ColorList: {
      type: cc.SpriteFrame,
      default: [],
    },
    across: 10,

    UIMian: cc.Node,

    _CheckItem: [], //选中的Item
    _DetectionItem: [],
    _ItemMaxList: [], //当前收益最大的数组
    _PromptCoolTime: 5,
    _IsTouch: true,

    _StartMoveDis: 300,
    _TouchState: "", //道具状态 ""：正常 "1"：锤子 "2":...
    _index: 0,
  },

  /**
   * 用于重置游戏中的各种状态和元素
   */
  Clear() {
    //   停止任何正在进行的提示动画。
    this.StopPromptAnimation();
    //   设置为 false，表示玩家没有失败
    this.isdeath = false;
    this.isPutCanDesing = false; //玩家输入且可以消除
    //   初始化为一个新的空数组，用于存储垂直列表
    this.allVerticalList = new Array();
    //   设置为空字符串，表示触摸状态的重置
    this._TouchState = "";
    //   清空 _CheckItem 数组，用于存储检查的项
    this._CheckItem.length = 0;
    //   表示没有重置
    this.isReset = false;
    //   表示允许触摸
    this._IsTouch = true;
    //   ，获取其 Item 组件并调用 Clear 方法，以清除每个子节点的状态
    for (var i = 0; i < this.ItemParent.children.length; i++) {
      this.ItemParent.children[i].getComponent("Item").Clear();
    }
  },

  onLoad() {
    FactoryItem.Instance = this;
    this.GameInitCom = cc.find("Canvas").getComponent("GameInit");
    this.ItemParent = cc.find("ItemParent");
    this.loadItem();
    this._StartMoveDis = 1000;
    this.allVerticalList = new Array(); //统计数列的数组
    this.isRunMax = true;
    this.isdeath = false;
    this.IsGameStart = false;
    this.isGameOver = false;
    this.isReset = false;
    //this.isResurtTimes = 3;
    this.constCoolTime = 3;
    this._PromptCoolTime = this.constCoolTime;
    this.isPutCanDesing = false; //玩家输入且可以消除
    this.UIMianCom = this.UIMian.getComponent("UIMian");
    FlyUI.Instance.UIMian = this.UIMian;
  },

  start() {
    this.Disx = 72;
    this.Disy = 73;
    this.ChildrenRankCom = cc.find("wx").getComponent("ChildrenRank");
  },

  loadItem() {
    for (var i = 0; i < 100; i++) {
      var item = cc.instantiate(this.ItemPrefabs);
      item.parent = this.ItemParent;
      item.active = false;
    }
  },
  /**
   * 用于在游戏中设置一些初始状态，并在一段时间后触发某些操作
   */
  GetDis() {
    var self = this;
    this.scheduleOnce(function () {
      // 设置 IsGameStart 为 true，表示游戏已经开始
      self.IsGameStart = true;
      // 表示可以响应触摸事件
      self._IsTouch = true;
      // 设置 _PromptCoolTime 为 constCoolTime，初始化提示冷却时间
      self._PromptCoolTime = self.constCoolTime;
      // 清空 _CheckItem 数组，表示清除检查项
      self._CheckItem.length = 0;
      //self.ChildrenRankCom.ShowOne();
    }, 1.5);
    // 置 isGameOver 为 false，表示游戏尚未结束
    this.isGameOver = false;
  },
  /**
   * 开局生成元素
   * @param {*} pos 生成位置
   * @param {*} num 编号
   * @param {*} index 颜色类型
   * @returns
   */
  CreatItem(pos, num, index) {
    // 检查 ItemParent 节点下的子节点数量是否达到 100 个
    // 如果已经达到 100 个，复用已有的项目（this.ItemParent.children[num]）
    // 否则，使用 cc.instantiate 方法创建一个新的项目实例
    var item =
      this.ItemParent.children.length == 100
        ? this.ItemParent.children[num]
        : cc.instantiate(this.ItemPrefabs);
    // 将项目节点设置为激活状态
    item.active = true;
    // 设置项目的位置，pos 是传入的位置，this._StartMoveDis 是初始移动距离。
    item.setPosition(cc.v2(pos.x, pos.y + this._StartMoveDis));
    // 将项目的缩放比例设置为 1。
    item.setScale(1);
    // 将项目的父节点设置为 ItemParent。
    item.parent = this.ItemParent;
    // 获取项目节点上的 Item 组件。
    var ItemCom = item.getComponent("Item");
    // 设置项目的颜色类型为 index。
    ItemCom._ColorType = index;
    // 设置项目的 ID 为 num + 1。
    ItemCom._ID = num + 1;
    // 设置项目是否被销毁为 false。
    ItemCom._isDestory = false;
    // 获取项目节点上的 cc.Sprite 组件，并设置其精灵帧为 this.ColorList[index]。
    item.getComponent(cc.Sprite).spriteFrame = this.ColorList[index];
    // 调用 ItemCom 的 HideLight 方法，隐藏项目的高亮效果。
    ItemCom.HideLight();
    //   分配竖列
    this.allocationVertical(num, item);
    return item;
  },

  CacheCreatItem(pos, num, _ColorType, _isDestory, _isHasBox) {
    var item =
      this.ItemParent.children.length == 100
        ? this.ItemParent.children[num]
        : cc.instantiate(this.ItemPrefabs);
    item.setPosition(cc.v2(pos.x, pos.y + this._StartMoveDis));
    item.setScale(1);
    item.parent = this.ItemParent;
    var index = _ColorType;
    var ItemCom = item.getComponent("Item");
    ItemCom._ColorType = index;
    ItemCom._ID = num + 1;
    item.getComponent(cc.Sprite).spriteFrame = this.ColorList[index];
    ItemCom._isDestory = _isDestory;
    ItemCom.HideLight();
    if (_isHasBox) {
      ItemCom.ShowBox();
    }
    this.allocationVertical(num, item);
    return item;
  },

  /**
   * 重新分配项目到垂直列中
   * @returns
   */
  RestAllocationVertical() {
    // 获取位置缓存数据
    var LoactionPosCache = FileServe.Instance.getLoactionPosCache();
    // 如果 LoactionPosCache 为 null，直接返回，不执行后续逻辑
    if (LoactionPosCache == null) return;
    // 初始化 allVerticalList 为空数组，用于存储重新分配后的垂直列数据
    this.allVerticalList = new Array();
    // 遍历每一列
    for (var key in LoactionPosCache) {
      // 初始化一个空数组 this.allVerticalList[key]
      this.allVerticalList[key] = [];
      // 遍历该列中的每一个元素的编号
      for (var i = 0; i < LoactionPosCache.length; i++) {
        // 计算项目的实际索引 num，即 LoactionPosCache[key][i] - 1
        var num = LoactionPosCache[key][i] - 1;
        // 获取元素节点 valueItem
        var valueItem = this.ItemParent.children[num];
        // 检查项目是否被销毁
        if (valueItem.getComponent("Item")._isDestory == false) {
          // 如果项目未被销毁，将其添加到当前列的数组中
          this.allVerticalList[key].push(valueItem);
        }
      }
    }
  },

  /**
   * 用于将（Item）分配到垂直列中
   * @param {*} num  编号
   * @param {*} myItem  节点
   * @returns
   */
  allocationVertical(num, myItem) {
    // 获取项目节点上的 Item 组件。
    var myItemCom = myItem.getComponent("Item");
    // 如果项目已经被销毁（_isDestory 为 true），直接返回，不执行后续逻辑
    if (myItemCom._isDestory) return;
    // 计算项目的索引。num 是项目的编号，this.across 是每行的item数量。index 表示项目在垂直列中的位置。
    var index = (num + 1) % this.across;
    // 检查 allVerticalList 是否为空。
    if (this.allVerticalList.length == 0) {
      // 如果为空，初始化 allVerticalList，创建 this.across 个空数组，每个数组代表一列。
      for (var i = 0; i < this.across; i++) {
        var _list = [];
        this.allVerticalList[i] = _list;
      }
    }
    // 遍历 allVerticalList 的每一个键（即每一列）。
    for (var key in this.allVerticalList) {
      // 计算实际的索引 _index。如果 index 为 0，则 _index 为 9；否则 _index 为 index - 1。
      var _index = index == 0 ? 9 : index - 1;
      // 如果当前列的键 key 等于 _index，将项目 myItem 添加到该列的数组中。
      if (key == _index) {
        this.allVerticalList[key].push(myItem);
      }
    }
  },
  /**
   * 用于设置所有项目在垂直列中的位置
   */
  setItemXY() {
    // 遍历 allVerticalList 的每一个键（即每一列）
    for (var key in this.allVerticalList) {
      // 遍历当前列中的每一个项目
      for (var i = 0; i < this.allVerticalList[key].length; i++) {
        // 获取当前项目的 Item 组件,传入当前列的索引 Number(key) 和项目在列中的索引 i
        this.allVerticalList[key][i].getComponent("Item").setXY(Number(key), i);
      }
    }
  },

  test() {
    var indexlist = [];
    var index = -1;
    for (var key in this.allVerticalList) {
      index++;
      if (this.allVerticalList[key].length == 0) {
        indexlist.push(index);
      }
    }
    for (var i = 0; i < indexlist.length; i++) {
      this.allVerticalList.splice(indexlist[i] - i, 1);
    }
    this.setItemXY();
    /*
        for(var key in this.allVerticalList)
        {
            for(var i = this.allVerticalList[key].length-1;i>=0;i--)
            {
                if(this.allVerticalList[key][i].getComponent("Item")._isDestory)
                {
                    this.allVerticalList[key].splice(i,1);
                }
            }
            if(this.allVerticalList[key] != null && this.allVerticalList[key].length == 0)
            {
                this.allVerticalList[key] = null
            }
        }
        */
  },

  /**
   * 用于将（Item）添加到检查列表中，并根据需要执行动画效果
   * @param {*} checkItem
   * @param {*} isAnimation
   * @returns
   */
  AddCheckItem(checkItem, isAnimation = true) {
    // 初始化变量 Ishas 为 -1，用于标记项目是否已经在检查列表中
    var Ishas = -1;
    // 遍历 this._CheckItem 列表，检查 checkItem 是否已经存在于列表中
    for (var i = 0; i < this._CheckItem.length; i++) {
      // 如果存在，返回 Ishas，即 -1，表示项目已存在
      if (checkItem == this._CheckItem[i]) {
        return Ishas;
      }
    }
    // 调用 checkItem 的 Item 组件的 ShowLight 方法，显示光标效果
    checkItem.getComponent("Item").ShowLight();
    // 将 checkItem 添加到 this._CheckItem 列表中
    this._CheckItem.push(checkItem);
    // 如果 isAnimation 为 true，表示需要执行动画效果
    if (isAnimation) {
      var checkItemCom = checkItem.getComponent("Item");
      checkItemCom._isDestory = true;
    }
    // 回 this._CheckItem 列表的当前长度
    return this._CheckItem.length;
  },

  /**
   * 检查元素是否存在,是否检查过
   * @param checkItem
   * @returns
   */
  AddMaxItem(checkItem) {
    var Ishas = false;
    for (var i = 0; i < this._DetectionItem.length; i++) {
      if (checkItem == this._DetectionItem[i]) {
        Ishas = true;
      }
    }
    if (!Ishas) {
      this._DetectionItem.push(checkItem);
      checkItem.getComponent("Item")._isAlreadyDetection = true;
    }
    return Ishas;
  },

  CompareItemList() {
    if (this._DetectionItem.length != 0) {
      if (this._DetectionItem.length > this._ItemMaxList.length) {
        this._ItemMaxList.length = 0;
        for (var i = 0; i < this._DetectionItem.length; i++) {
          this._ItemMaxList.push(this._DetectionItem[i]);
        }
      }
      this._DetectionItem.length = 0;
    }
  },
  /**
   * 销毁选中及相连的元素
   * @param IsSetValue
   */
  ClearCheckItem(IsSetValue = -1) {
    var self = this;
    //   取消所有已安排的回调函数，确保没有遗留的定时任务。
    this.unscheduleAllCallbacks();
    var count = this._CheckItem.length - 1;
    var index = -1;
    //   每隔 0.02 秒执行一次，总共执行 count 次，从 0 开始
    this.schedule(
      function () {
        index++;
        if (index < self._CheckItem.length) {
          // 播放销毁动画
          self._CheckItem[index].getComponent("Item").PlayDestoryAnimation();
          // IsSetValue 为 -1，分数为 5 + 10 * index
          if (IsSetValue == -1) {
            var addScore = 5 + 10 * index;
          } else {
            var addScore = 10;
          }
          // 创建分数飞行动画
          FlyUI.Instance.CreatorScoreFly(
            self._CheckItem[index].getPosition(),
            this.UIMian.getComponent("UIMian").ScoreUIPos,
            addScore
          );
          // 处理完所有项
          if (index == count) {
            if (IsSetValue == -1) {
              self.ShowPromptUI(false);
            } else {
              self.ShowPromptUI(true);
            }
            self.GetColorEgg();
            self.ClearCheckItem2();
          }
        }
      },
      0.02,
      count,
      0
    );
  },
  /**
   * 用于在游戏过程中显示得分提示U
   * @param {*} isSkill
   */
  ShowPromptUI(isSkill = false) {
    var lengths = this._CheckItem.length;
    // 显示得分提示UI，传入 lengths 和 isSkill 参数。
    this.UIMianCom.ShowGetScoreUI(lengths, isSkill);

    var value = lengths - 5;

    if (value >= 4) {
      value = 3;
    }
    // 根据消除多少来播放鼓励词语
    if (value >= 0) {
      this.UIMianCom.UIPromptStar.getComponent("UIPromptStar").PlayUI(value);
      SoundManage.Instance.playPromptSound(value);
    }
  },

  //每组结算生产彩蛋
  GetColorEgg() {
    var ColorEggState = "";
    for (var i = 0; i < this._CheckItem.length; i++) {
      if (this._CheckItem[i].getComponent("Item")._isHasBox) {
        UIManage.Instance.ShowGetBoxUI();
        ColorEggState = "Box";
        break;
      }
    }

    //if(this.UIMianCom._PlayInfo._Level == 1)
    //   return;

    if (ColorEggState == "" && this.UIMianCom._PlayInfo._IsShowSkill == false) {
      var value = Math.floor(Math.random() * 100);
      if (value < 2) {
        this.UIMianCom._PlayInfo._IsShowSkill = true;
        UIManage.Instance.ShowGetSkill(); //消灭同种颜色技能UI
        ColorEggState = "Skill";
      }
    }
  },

  ClearCheckLight() {
    for (var i = 0; i < this._CheckItem.length; i++) {
      var itemComm = this._CheckItem[i].getComponent("Item");
      itemComm.LightUI.active = false;
      itemComm._isDestory = false;
    }
    this._CheckItem.length = 0;
    this._IsTouch = true;
  },
  /**
   * 用于在游戏中清除检查列表中的项目，并处理项目的移动和动画效果
   */
  ClearCheckItem2() {
    // 遍历 this.allVerticalList 中的每一个键
    for (var key in this.allVerticalList) {
      // 初始化变量 step 为 0，用于记录连续需要销毁的项目数量
      var step = 0;
      if (this.allVerticalList[key] == null) continue;
      var indexlist = [];
      for (var i = 0; i < this.allVerticalList[key].length; i++) {
        var _Item = this.allVerticalList[key][i].getComponent("Item");
        if (_Item._isDestory) {
          step++;
          indexlist.push(i);
          //this.allVerticalList[key].splice(i,1);
        } else if (step > 0) {
          this.MoveDownItem(step, this.allVerticalList[key][i]);
        }
      }
      for (var i = 0; i < indexlist.length; i++) {
        this.allVerticalList[key].splice(indexlist[i] - i, 1);
      }
    }
    var self = this;
    this.scheduleOnce(function () {
      var isleftAni = self.LeftClear();
      var timer = isleftAni == true ? 0.1 : 0;

      self.scheduleOnce(function () {
        self.IsPass();
        self.IsDeath();
        self.UIMianCom.UpdateFreindRank();
        self._IsTouch = true;
      }, timer);
    }, 0.4);

    this._CheckItem.length = 0;
  },

  IsPass() {
    if (
      this.UIMianCom._PlayInfo._IsShowPass == false &&
      this.UIMianCom.IsPass()
    ) {
      this.UIMianCom._PlayInfo._IsShowPass = true;
      this.UIMianCom.UIPromptStar.getComponent("UIPromptStar").Pass();
      SoundManage.Instance.playPassSound();
    }
  },
  /**
   * 清除左边
   */
  LeftClear() {
    var isleftAni = false;
    var leftstep = 0;
    var index = -1;
    var indexlist = [];
    for (var _key1 in this.allVerticalList) {
      index++;
      if (
        this.allVerticalList[_key1] != null &&
        this.allVerticalList[_key1].length == 0
      ) {
        leftstep++;
        this.allVerticalList[_key1] = null;
        indexlist.push(index);
      } else if (leftstep > 0 && this.allVerticalList[_key1] != null) {
        for (var i = 0; i < this.allVerticalList[_key1].length; i++) {
          this.MoveleftItem(leftstep, this.allVerticalList[_key1][i]);
          if (!isleftAni) isleftAni = true;
        }
      }
    }
    for (var i = 0; i < indexlist.length; i++) {
      this.allVerticalList.splice(indexlist[i] - i, 1);
    }
    return isleftAni;
  },
  /**
   * 元素向下移动
   */
  MoveDownItem(step, item) {
    item.getComponent("Item")._Y -= step;
    var pos = item.getPosition();
    var numx = Number(pos.x.toFixed(1));
    var numy = Number(pos.y.toFixed(1));
    var targetPos = cc.v2(numx, numy - this.Disy * step);

    var move = cc.moveTo(0.15, targetPos);
    var move1 = cc.moveBy(0.1, cc.v2(0, 20));
    var move2 = cc.moveBy(0.05, cc.v2(0, -20));

    item.runAction(cc.sequence(move, move1, move2));
  },
  /**
   * 元素向左移动
   */
  MoveleftItem(step, item) {
    item.getComponent("Item")._X -= step;
    var pos = item.getPosition();
    var numx = Number(pos.x.toFixed(1));
    var numy = Number(pos.y.toFixed(1));
    var targetPos = cc.v2(numx - this.Disx * step, numy);

    //item.getComponent("Item")._ID - step;
    var move = cc.moveTo(0.1, targetPos);

    item.runAction(move);
  },
  /**
   * 检查游戏是否结束
   * @returns
   */
  IsDeath() {
    //   如果 isPutCanDesing 为 true 且 IsGameStart 为 false，则直接返回，不执行后续逻辑
    if (this.isPutCanDesing && this.IsGameStart == false) {
      return;
    }
    //   初始化 isdeath 变量为 true，表示游戏结束
    var isdeath = true;
    for (var i = 0; i < this.ItemParent.children.length; i++) {
      var ItemCom = this.ItemParent.children[i].getComponent("Item");
      // 如果项目未被销毁（_isDestory 为 false），调用 detectionSameItem 方法检测是否有相同的项目可以消除
      if (ItemCom._isDestory == false) {
        isdeath = ItemCom.detectionSameItem(true, true);
        //   如果检测到有可消除的项目，将 isdeath 设置为 false 并跳出循环
        if (isdeath == false) {
          break;
        }
      }
    }
    //   isdeath 仍为 true，表示没有可消除的项目
    if (isdeath != false) {
      // GetNotDestoryItem 方法获取所有未被销毁的项目列表
      var surplusList = this.GetNotDestoryItem();
      if (
        surplusList.length >= 10 &&
        this.UIMianCom._PlayInfo._Score < this.UIMianCom._PlayInfo._NeedScore &&
        this.GameInitCom.PopsList.Reset > 0
      ) {
        UIManage.Instance.ShowUIHintProp(() => {
          this.GameOverAni(surplusList);
        });
      } else {
        this.GameOverAni(surplusList);
      }
    }
  },

  GetNotDestoryItem() {
    var surplusList = [];
    var itemchildren = this.ItemParent.children;
    for (var i = 0; i < itemchildren.length; i++) {
      if (itemchildren[i].getComponent("Item")._isDestory == false) {
        surplusList.push(itemchildren[i]);
      }
    }
    return surplusList;
  },
  /**
   * 用于在游戏结束时显示动画效果，并处理剩余方块的得分和动画
   * @param {*} surplusList 表示剩余的方块列表
   */
  GameOverAni(surplusList) {
    //   表示游戏已经结束
    this.IsGameStart = false;
    //   表示游戏没有重置
    this.isReset = false;
    //  存储剩余方块的数量
    var count = surplusList.length;
    if (count > 0) {
      // 迟 0.5 秒后执行动画
      this.scheduleOnce(function () {
        //   遍历所有剩余方块，为每个方块添加闪烁动画
        for (var i = 0; i < count; i++) {
          var action = cc.blink(0.8, 2);
          surplusList[i].getComponent("Item").ShowLight();
          surplusList[i].runAction(action);
        }
        //   初始化 index 为 -1，用于记录当前处理的方块索引
        var index = -1;
        var self = this;
        //显示剩余方块 最高奖励分
        this.UIMianCom.ShowRemian(2000, count);
        this.schedule(
          function () {
            index++;
            var scoreValue = 2000 - (index + 1) * (index + 1) * 20;
            if (scoreValue < 0) {
              scoreValue = 0;
            }
            self.UIMianCom.ShowRemian(scoreValue, count);
            surplusList[index].getComponent("Item").PlayDestoryAnimation();
            surplusList[index].getComponent("Item")._isDestory = true;

            if (index == count - 1) {
              if (count < 10) {
                var value = 2000 - count * count * 20;
              } else {
                var value = 0;
              }
              self.scheduleOnce(function () {
                self.UIMianCom.AddRemianScore(value, () => {
                  //self.UIMianCom.IsSuccess();
                  self.UIMianCom.NextLevel();
                  self.UIMianCom.HideRemian();
                  cc.log("结算动画结束");
                  // 过关红包
                  if (Utils.isPopRed()) {
                    UIManage.Instance.ShowOpenMoney((src) => {
                      src.init(2);
                    });
                  }
                });
              }, 1.2);
            }
          },
          0.04,
          count - 1,
          1
        );
      }, 0.5);
    } else {
      var self = this;
      this.UIMianCom.ShowRemian(2000, count);
      this.scheduleOnce(function () {
        //this.UIMianCom.setLableUI(2000);
        self.UIMianCom.AddRemianScore(2000, () => {
          //this.UIMianCom.IsSuccess();
          self.UIMianCom.NextLevel();
          self.UIMianCom.HideRemian();
        });
      }, 1);
    }
  },

  //提示场景中最大的数组
  GetMaxItem() {
    for (var i = 0; i < this.ItemParent.children.length; i++) {
      var ItemCom = this.ItemParent.children[i].getComponent("Item");
      if (ItemCom._isDestory == false) {
        if (ItemCom._isAlreadyDetection) {
          ItemCom._isAlreadyDetection = false;
          continue;
        }
        ItemCom.detectionSameItem();
      }
    }

    for (var j = 0; j < this._ItemMaxList.length; j++) {
      //提示星星动画
      this._ItemMaxList[j].getComponent("Item").PromptAnimation();
    }
  },

  StopPromptAnimation() {
    for (var j = 0; j < this._ItemMaxList.length; j++) {
      this._ItemMaxList[j].getComponent("Item").StopPromptAnimation();
    }
    this._PromptCoolTime = this.constCoolTime;
    this.isRunMax = true;
    this._ItemMaxList.length = 0;
    this._DetectionItem.length = 0;
  },

  Init() {
    this.GameInitCom.Init();
  },

  update(dt) {
    if (this.IsGameStart == false) {
      return;
    }
    this._PromptCoolTime -= dt;
    if (this._PromptCoolTime <= 0) {
      if (this.isRunMax) {
        this.GetMaxItem();
        this.isRunMax = false;
      }
    }
  },

  //锤子道具
  HammerProps(Item) {
    this._CheckItem.push(Item);
    Item.getComponent("Item")._isDestory = true;
    this.ClearCheckItem();
    this.UIMianCom.CancelProps();
  },

  ShowItemLight(_ItemCom) {
    if (this.ItemLastCom != undefined) {
      this.ItemLastCom.HideLight();
    }
    _ItemCom.ShowLight();
    this.ItemLastCom = _ItemCom;
  },

  //改变颜色道具
  ChangeProps(Item) {
    this.UIMianCom.UIProposChangePanel.getComponent(
      "UIProposChangePanel"
    ).ShowUI(Item);
    //this.UIMianCom.CancelProps(false);
    this.ShowItemLight(Item.getComponent("Item"));
  },

  //重组道具
  PropsRest() {
    this.StopPromptAnimation();
    var IndexList = [];
    var Vlist = [];
    var VlistX = [];
    var KeyList = [];
    var _index = -1;
    for (var key in this.allVerticalList) {
      if (this.allVerticalList[key] != null) {
        _index++;
        Vlist.push(this.allVerticalList[key]);
        VlistX.push(this.allVerticalList[key][0].getPosition().x);
        IndexList.push(_index);
        KeyList.push(key);
      }
    }
    var alllist = {};
    for (var i = 0; i < Vlist.length; i++) {
      var value = Math.floor(Math.random() * IndexList.length);
      var real = IndexList[value];
      IndexList.splice(value, 1);

      var posX = VlistX[i];

      alllist[i] = Vlist[real];
      for (var j = 0; j < Vlist[real].length; j++) {
        var startPOS = Vlist[real][j].getPosition();

        Vlist[real][j].setPosition(cc.v2(posX, startPOS.y));
      }
    }
    var _i = -1;
    for (var key in this.allVerticalList) {
      _i++;
      if (alllist[_i] != undefined) {
        this.allVerticalList[key] = alllist[_i];
        for (var j = 0; j < this.allVerticalList[key].length; j++) {
          var Item = this.allVerticalList[key][j];
          var ItemCom = Item.getComponent("Item");

          if (!ItemCom._isDestory) {
            var Indexs = Math.floor(Math.random() * 5);
            Item.getComponent(cc.Sprite).spriteFrame = this.ColorList[Indexs];
            ItemCom._ColorType = Indexs;
            var keyValue = Number(key) + 1;
          }
        }
      } else {
        this.allVerticalList[key] = null;
      }
    }
    this.setItemXY();
    this.isReset = true;
    this.IsDeath();
  },

  //消除同一个颜色道具
  DestorySameColorProps() {
    this.StopPromptAnimation();
    var colorType = -1;
    for (var i = 0; i < this.ItemParent.children.length; i++) {
      var Item = this.ItemParent.children[i];
      if (!Item.getComponent("Item")._isDestory) {
        if (colorType == -1) {
          colorType = Item.getComponent("Item")._ColorType;
        }
        if (Item.getComponent("Item")._ColorType == colorType) {
          this._CheckItem.push(Item);
          Item.getComponent("Item")._isDestory = true;
        }
      }
    }
    this.ClearCheckItem(10);
  },
  //缓存
  Cache() {
    if (this.IsGameStart && this._IsTouch) {
      FileServe.Instance.StartItemCache(); //储存关卡数和Item的位置
    } else {
      FileServe.Instance.SetPlayInfoCache(); //只存关卡数
    }
  },
  //删除缓存
  RemoveCache() {
    FileServe.Instance.DestoryItemPlayCache();
  },
});
